perm filename U.TEX[RDG,DBL]1 blob
sn#529713 filedate 1980-08-22 generic text, type C, neo UTF8
COMMENT ā VALID 00003 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 \input UNIT.TEX[RLL,RDG]
C00046 00003 \SlotEntry <{ToParseParts} {FSingleton FunctionType} {This value is used by each
C00081 ENDMK
Cā;
\input UNIT.TEX[RLL,RDG]
\ClassEntry <{Anything} 1 {The topmost node, in all the hierarchies.}>
\CFact SubClass@
AnyAT&U AnyAbstractThing AnyCT&U AnyConcreteThing AnyUnit>
\CFact Direct Examples@AnyClassOfObjects>
\SlotsFor {thing}
\SlotEntry <{Isa} {FSet (UnitType (*P AnyClassOfObjects))} {This primitive slot
is the fundamental hierarchical link in this system, specifying those classes to
which this unit belongs. Note that its format is SET - hence this system can handle
a DAG structure; better for our purposes than a tree.}>
\SFact Inverse@Examples>
\SlotEntry <{Characteristics} {FSet NonNILType} {This lists some essential characteristics
of this unit. (Not currently in use.)}> \SFact HighLevelDefn@(Unioning FunctionCharacter FormatCharacter)>
\SlotEntry <{Descr} {FSingleton NonNILType} {This describes this unit. (It is used
to generate this document.)}>
\SlotEntry <{AllIsas} {FSet UnitType} {This specifies each class to which this unit
belongs. (It includes each \Slot (SuperClass) \ of this unit's \Slot (Isa) \ slot.
)}> \SFact Inverse@AllExamples>
\SFact HighLevelDefn@(Composition SuperClass* Isa)>
\SlotEntry <{AllGenls} {FSet UnitType} {This points to a list of those units which
are somehow more general than this unit.}> \SFact Inverse@AllSpecs>
\SFact HighLevelDefn@(Unioning Prototypes (OneOf SuperClass* SuperTypEx* SuperSlot* GenlAct*))>
\SlotEntry <{AllSpecs} {FSet UnitType} {This lists every unit which is somehow more
precise than this unit.}> \SFact Inverse@AllGenls>
\SFact HighLevelDefn@(Unioning AllTypicalExampleOfs (OneOf SubClass* SubTypEx* SubSlot* SpecAct*))>
\SlotEntry <{Prototypes} {FSet (UnitType (*P AnyArchetype))} {This points to each
typical example of this unit, not necessarily in order of increasing generality.
}> \SFact Inverse@AllTypicalExampleOfs>
\SFact HighLevelDefn@(Composition TypicalExample AllIsas)>
\SlotEntry <{Specializations} {FSet UnitType} {This points to each unit which ``specializes''
this unit.}> \SFact Inverse@Generalizations>
\SFact HighLevelDefn@(OneOf SubSlot SpecAct SubTypEx SubDT SubClass)>
\SlotEntry <{OrderedPrototypes} {FOrderedSet UnitType} {Enumerates the prototypes
of this unit in order of increasing generality (i.e. \Unit (TypicalDog) \ would
precede \Unit (TypicalAnimal) .)}> \SFact HighLevelDefn@(PutInOrder Prototypes SuperTypEx* NIL MembForOrdPro)>
\ClassEntry <{AnyAT&U} 2 {This is a HACK - to deal with the units in this system,
which represent both some abstract object (NOT in the world,) and themselves...
}> \CFact SuperClass@Anything>
\CFact SubClass@AnyIntensionalObject>
\ctrline{\it The slots appropriate for all ``AT&U''s are those defined for each of: (
\Unit (AnyUnit)\ \Unit (AnyAbstractThing)\ ).}
\ClassEntry <{AnyIntensionalObject} 3 {Descendants of this unit describe some
entity in the world intensionally -- as opposed to directly referring to in.}> \CFact SuperClass@
AnyAT&U AnyCT&U>
\CFact SubClass@AnyArchetype AnyDescriptor AnyUnitForSlot AnyVariable>
\ClassEntry <{AnyArchetype} 4 {Every typical example of some class is an archetype,
and descends from this unit.}> \CFact SuperClass@AnyIntensionalObject>
\hmode{\qquad There are currently 111 examples.}\par
\SlotsFor {Archetype}
\SlotEntry <{NewPossibleSlots} {FSet SlotType} {This lists the names of slots which
are meaningful for every ``instance'' of this typical example. Furthermore, this
is the highest place where this slot is meaningful (hence the ``{\sl new}ness''
of the name.)}> \SFact Inverse@MakesSenseFor>
\SFact HighLevelDefn@(Composition (Soften NewPossibleSlots) MyComposeOf)>
\SlotEntry <{TypicalExampleOf} {FSingleton (UnitType (*P AnyClassOfObjects))} {Refers
back, from the typical example unit, to the class of elements it typifies.}> \SFact Inverse@TypicalExample>
\SlotEntry <{SuperTypEx} {FSet UnitType} {This denotes the relation connecting \Unit
(TypicalDog) \ to \Unit (TypicalAnimal) \ -- i.e. a superset relation holds between
the elements each (respectively) typifies.}> \SFact Inverse@SubTypEx>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass TypicalExampleOf)>
\SlotEntry <{SubTypEx} {FSet UnitType} {See \Slot (SuperTypEx) .}> \SFact Inverse@SuperTypEx>
\SFact HighLevelDefn@(Composition TypicalExample SubClass TypicalExampleOf)>
\SlotEntry <{PossibleSlots} {FSet UnitType} {This is obsolete - and will soon be
deleted.}> \SFact HighLevelDefn@(Composition NewPossibleSlots SuperTypEx*)>
\SlotEntry <{SuperTypEx*} {FSet UnitType} {This is the transitive closure of \Slot
(SuperTypEx) .}> \SFact Inverse@SubTypEx*>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass* TypicalExampleOf)>
\SlotEntry <{SubTypEx*} {FSet (UnitType (*P AnyArchetype))} {This is the transitive
closure of \Slot (SubTypEx) .}> \SFact Inverse@SuperTypEx*>
\SFact HighLevelDefn@(Composition TypicalExample SubClass* TypicalExampleOf)>
\ClassEntry <{AnyDescriptor} 5 {This will eventually hold descriptors -- a whole
class of entities which will have to be defined...}> \CFact SuperClass@AnyIntensionalObject
>
\ClassEntry <{AnyUnitForSlot} 6 {At times, there is more than just one ``morsel''
of information needed to describe the value of some unit's slot. RLL then devotes
an entire unit to hold this information. Such units descend from this \Unit (AnyUnitForSlot.
)}> \CFact SuperClass@AnyIntensionalObject>
\SlotsFor {UnitForSlot}
\SlotEntry <{*vaLue*} {FSingleton NonNILType} {When a unit is allocated to store
facts about the value of a slot, the actual value of that slot, if any, is kept
in the \Slot (*vaLue*) \ slot of that sub unit.}> \SFact HighLevelDefn@(Application (Composition Defn LivesInSlot) LivesInUnit)>
\ClassEntry <{AnyVariable} 7 {This class contains the universally or existentially
bound variables. Note that this is a META description of said units.}> \CFact SuperClass@
AnyIntensionalObject>
\ClassEntry <{AnyAbstractThing} 8 {Instances refer to intangible objects; as
opposed to concrete things (such as real world people or units) .}> \CFact SuperClass@
Anything>
\ClassEntry <{AnyCT&U} 9 {This is a HACK - to deal with the units in this system,
which represent both some object in the world, and themselves...}> \CFact SuperClass@
Anything>
\CFact SubClass@AnyClassOfObjects AnyDatatype AnyDecomposableObject AnyFormat AnyInheritance
AnyIntensionalObject AnyOverhead AnyProcess AnyUnit AnyUser>
\ctrline{\it The slots appropriate for all ``CT&U''s are those defined for each of: (
\Unit (AnyUnit)\ \Unit (AnyConcreteThing)\ ).}
\ClassEntry <{AnyClassOfObjects} 10 {Every member of this class is itself a set.
}> \CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyClassOfPhysicalObjects AnyFiniteSet AnySetOfClauses AnySymbol
>
\hmode{\qquad There are currently 120 examples.}\par
\SlotsFor {ClassOfObjects}
\SlotEntry <{TypicalExample} {FSingleton (UnitType (*P AnyArchetype))} {This points
from a class to an abstract entity which holds default information about members
of this class.}> \SFact Inverse@TypicalExampleOf>
\SlotEntry <{DomainOf} {FSet (UnitType (*P AnyFunction))} {If a function takes one
or more elements of this class, as arguments, that function is stored on the \LispFn
(DomainOf) \ slot of the unit representing that class.}> \SFact Inverse@Domain>
\SlotEntry <{RangeOf} {FSet (UnitType (*P AnyFunction))} {If a function maps into
this class (or a space having this class as one dimension,) that function is stored
on the \LispFn (RangeOf) \ slot of the unit representing that class.}> \SFact Inverse@Range>
\SlotEntry <{IntensionalExamples} {FSet UnitType} {Fill in later.}>
\SlotEntry <{StdExamples} {FSet UnitType} {This slot basically represents the vanilla
``\EPSILON'' relationship, between an extensional object, and a represented set.
}>
\SlotEntry <{SuperClass} {FSet (UnitType (*P AnyClassOfObjects))} {This points from
a class, C, to each superset of C, D\Sub (i) . That is, x \EPSILON C => x \EPSILON
D\Sub (i) , for all elements x, and all sets, D\Sub (i) .}> \SFact Inverse@SubClass>
\SlotEntry <{SubClass} {FSet UnitType} {This points from a class, C, to each subset
of C.}> \SFact Inverse@SuperClass>
\SlotEntry <{Examples} {FSet UnitType} {This points from a class to each member
of that class. (Both constant and variable.)}> \SFact Inverse@Isa>
\SFact HighLevelDefn@(Unioning IntensionalExamples StdExamples)>
\SlotEntry <{TotalSoFar} {FSingleton IntegerType} {Fill in later.}>
\SlotEntry <{SuperClass*} {FSet UnitType} {A list of a unit's SuperClass, THEIR
SuperClass, etc.}> \SFact Inverse@SubClass*>
\SFact HighLevelDefn@(Starring SuperClass)>
\SlotEntry <{SubClass*} {FSet UnitType} {A list of a unit's SubClass, THEIR SubClass,
etc.}> \SFact Inverse@SuperClass*>
\SFact HighLevelDefn@(Starring SubClass)>
\SlotEntry <{AllExamples} {FSet UnitType} {This points from a class to a list of
members of this class. (\Slot (Examples) \ only pointed to elements immediately
a member of some set --- this will follow their \Slot (SuperClass) \ links as well,
to more accurately represent an ``\EPSILON'' relation.)}> \SFact Inverse@AllIsas>
\SFact HighLevelDefn@(Composition Examples SubClass*)>
\SlotEntry <{GenlsModels} {FSet (UnitType (*P AnyArchetype))} {This is used for
several of the inheritances. The prototypes of every example of some class include
that class's \Slot (GenlsModels) .}> \SFact HighLevelDefn@(Composition TypicalExample SuperClass*)>
\ClassEntry <{AnyDatatype} 11 {Every datatype (used for building up type specifications,
) descends from this.}> \CFact SuperClass@AnyCT&U>
\hmode{\qquad There are currently 12 examples.}\par
\SlotsFor {Datatype}
\SlotEntry <{EqualDTSpec} {FSet (FListN (UnitType (*P AnyDatatype)) UnrestrictedType
)} {This helps relate one datatype to another -- by defining a set of equivalent
datatype-datarange pairs.}>
\SlotEntry <{VerifyType} {FSingleton FunctionType} {\UnitSlot (DT:VerifyType) is
a predicate, returning non{\LispFn (NIL) } for all elements which qualify in this
datatype.}>
\SlotEntry <{GenerateAll} {FSingleton FunctionType} {\UnitSlot (DT:GenerateAll)
returns a list of all members of the datatype, \Unit (DT) .}>
\SlotEntry <{SuperDT} {FSet (UnitType (*P AnyDatatype))} {This points to the list
of more general datatypes -- i.e. those which contain a superset of this datatype's
members.}> \SFact Inverse@SubDT>
\SlotEntry <{SubDT} {FSet (UnitType (*P AnyDatatype))} {\UnitSlot (DT:SubDt) points
to Datatypes which accept a subset of those accepts by the datatype \Unit (DT)
.}> \SFact Inverse@SuperDT>
\SlotEntry <{RangeInterpreter} {FSingleton FunctionType} {\UnitSlot (DT:RangeInterpreter
) is a function which helps parse the value of \UnitSlot (S:DataRange) , which is
used to determine the appropriate values to fill \UnitSlot (U:S) .}>
\SlotEntry <{IsTypeOf} {FSet SlotType} {Points from a datatype to those units representing
functions whose range is composed of this datatype.}> \SFact Inverse@Datatype>
\SlotEntry <{SuperDT*} {FSet (UnitType (*P AnyDatatype))} {A list of a unit's SuperDT,
THEIR SuperDT, etc.}> \SFact Inverse@SubDT*>
\SFact HighLevelDefn@(Starring SuperDT)>
\SlotEntry <{SubDT*} {FSet (UnitType (*P AnyDatatype))} {Transitive closure of \Unit
(SubDT) .}> \SFact Inverse@SuperDT*>
\SFact HighLevelDefn@(Starring SubDT)>
\ClassEntry <{AnyDecomposableObject} 12 {Descendants of this are real world entities
which consist of several subparts; and which are little more than the union of
such pieces.}> \CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyActionSequence AnyClaus>
\SlotsFor {DecomposableObject}
\SlotEntry <{ComposedOf} {FSet NonNILType} {This points to a list of the parts associated
with this entity.}>
\ClassEntry <{AnyActionSequence} 13 {Any compound action, composed a sequence
of subactions, descends from this unit.}> \CFact SuperClass@AnyAction AnyDecomposableObject
>
\CFact Direct Examples@DungeonAdventure Adventure Encounter>
\SlotsFor {ActionSequence}
\SlotEntry <{SubActions} {FList NonNILType} {Each action may be broken into a series
of substeps -- each of which is a ``subaction''.}>
\ClassEntry <{AnyFormat} 14 {From this descends the units which each serve to
describe some format; which can be used in a type description.}> \CFact SuperClass@
AnyCT&U>
\CFact SubClass@AnySlotFormat AnyValueFormat>
\SlotsFor {Format}
\SlotEntry <{FnForAdding} {FSingleton FunctionType} {One should add a new entry
to a Ordered LIST in a different manner than one uses to add a value to an Unordered
SET. (In the first case, multiple occurances of an element are acceptable; which
is NOT true in the second case.) This information is contained in the function
stored in \UnitSlot (F:FnForAdding) . Note it is used by the various {\LispFn (Add
) }ing functions -- such as the one employed to add a new entry to the existing
value of a unit's slot.}>
\SlotEntry <{FnForDeleting} {FSingleton FunctionType} {There are different ways
of deleting an element from a list, versus from a set. As with \Slot (FnForAdding
) , this information is stored in \UnitSlot (F:FnForDeleting) , where \Unit (F)
\ is the name of a format.}>
\SlotEntry <{FnForKilling} {FSingleton FunctionType} {To handle indirect pointers
using the \LispFn (*Do*) \ special slot values, one needs assistance to describe
how to perform various manipulations -- such as deleting a full slot's value. This
information is kept in \UnitSlot (VF:FnForKilling) , where \Unit (VF) \ is a value
format.}>
\SlotEntry <{FnForVerifyingAll} {FSingleton FunctionType} {This is used, in conjunction
with the various verifying functions associated with each datatype, to build the
function stored in the \Slot (VerifyValue) \ slot of each slot. It indicates how
to verify that a full entry is correct, given, (among other arguments,) the predicate
to apply to each entry individually.}>
\SlotEntry <{FnForVerifyingElement} {FSingleton FunctionType} {This is used to verify
that a single element is correct. (Perhaps this isn't used anymore -- I must look
into this.)}>
\SlotEntry <{FormatCharacter} {FSet NonNILType} {This holds a list of specifications
for some format. It is not currently used for anything but show.}>
\SlotEntry <{FnForGetting} {FSingleton FunctionType} {This is used to determine
the value of a special slot value, to be returned when \LispFn (GetValue) \ requests
its value.}>
\SlotEntry <{FnForPutting} {FSingleton FunctionType} {This indicates how to put
a value. It is basically used for indirect pointers.}>
\ClassEntry <{AnySlotFormat} 15 {Descendants are used in type specifications,
for processes (which include functions and slots) .}> \CFact SuperClass@AnyFormat
>
\CFact Direct Examples@FSingleton FList FSet FOrderedSet FBag FListN>
\ClassEntry <{AnyValueFormat} 16 {Descendants are used in a \LispFn (*Do*) \
special slot value format. This has applications as indirect pointers, as well as
to put epistemological marks on some value.}> \CFact SuperClass@AnyFormat>
\CFact SubClass@AnyIndirectPtrFormat>
\CFact Direct Examples@FOneOf FExecute>
\ClassEntry <{AnyIndirectPtrFormat} 17 {These are used to deal with subunits,
and other places where much data is stored at another location -- other than \UnitSlot
(U:S) .}> \CFact SuperClass@AnyValueFormat>
\CFact Direct Examples@FSeeUnit FSeeSlot FSeeU&S>
\ClassEntry <{AnyInheritance} 18 {All modes of inheritance will descend from
here. Associated with each instance of an inheritance is a means for creating new
units, and constraints on properties these units may acquire. (and maybe other
things...)}> \CFact SuperClass@AnyCT&U>
\CFact Direct Examples@IExamples ISubClass ITypEx>
\SlotsFor {Inheritance}
\SlotEntry <{UseToGetSlots} {FSingleton NonNILType} {This points to a high level
definition of a function which is takes the parent units, and returns a list of
units whose \Slot (NewPossibleSlots) \ slot together hold the slots which should
be initialized in this new offspring.}>
\SlotEntry <{GetPossibleSlotsFn} {FSingleton SlotType} {This points a unit which
represents a function, which takes the units found using the \Slot (UseToGetSlots
) \ function mentioned above, and returns a list of values with which to initialize
a new unit. Each entry in this ordered list is a triple, consisting of the name
of the slot, followed by the location of the relevant initializing function, and
the typical example in which this slot was found.}> \SFact Inverse@UsedByInheritance>
\ClassEntry <{AnyOverhead} 19 {Miscellaneous information needed by CORLL, etc.,
is stored on units which descend from here.}> \CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyStatus>
\ClassEntry <{AnyStatus} 20 {This will father all *.STATUS units}> \CFact SuperClass@
AnyOverhead>
\CFact Direct Examples@GENLINFO.STATUS BIOLOGY.STATUS RLL.STATUS HOBBIT.STATUS HEURS.STATUS
NUMBER.STATUS MATH.STATUS SETS.STATUS OLD.STATUS>
\SlotsFor {Status}
\SlotEntry <{KBsVARS} {FSingleton NonNILType} {This names a variable, whose value
lists the variables associated with this Knowledge Base.}>
\SlotEntry <{KBsConnectedTo} {FSet (UnitType (*P AnyStatus))} {The value of { \UnitSlot
(<kb>.STATUS:KBsConnectedTo) \ } is a list of other status units, which were resident
in core the last time this Knowledge Base, { <kb>, } was used. It is reset whenever
a new Knowledge Base is read in, or whenever one is disconnected or reconnected.
}> \SFact Inverse@KBsConnectedTo>
\SlotEntry <{OpenDate} {FSingleton StringType} {This holds the time stamp when this
Knowledge Base was openned -- i.e. the start of this session.}>
\SlotEntry <{NetworkStatus} {FSingleton NonNILType} {This stores the last person
to use this Knowledge Base, and when that last use was.}>
\SlotEntry <{WhenOpeningNetwork} {FSingleton UnrestrictedType} {This points to a
list of functions which CORLL calls when openning this Knowledge Base. Each takes
two arguments -- the first is the name of this KB, and the second is passed from
\LispFn (WhenOpenningNetworks) , serves to suppress questions and messages.}>
\SlotEntry <{LoadFiles} {FSet NonNILType} {This lists the files which CORLL will
read in whenever it opens this network. It will also ask if it should \LispFn (
MAKEFILE) \ these when this Knowledge Base is closed.}>
\SlotEntry <{KBsFNS} {FSingleton NonNILType} {This points to a variable whose value
lists the functions relevant to this Knowledge Base.}>
\SlotEntry <{WhenWritingNetwork} {FSingleton NonNILType} {This points to a list
of functions which CORLL calls when writing out this Knowledge Base. Each takes
two arguments -- the first is the name of this KB, and the second is passed from
\LispFn (WhenWritingNetworks) , serves to suppress questions and messages.}>
\SlotEntry <{Networks} {FSet KBType} {Each Knowledge Base may depend, hierarchically,
on the presence of other knowledge bases, in core. The KBs {\Unit (<kb>) } requires
are listed in {\UnitSlot (<kb>.STATUS:Networks) }.}>
\SlotEntry <{KBsUnitIndex} {FSingleton NonNILType} {This points to the unit which
holds the unit index CORLL uses for this Knowledge Base.}>
\SlotEntry <{KBsFreeBlockIndex} {FSingleton NonNILType} {This points to the unit
which holds the free block index CORLL uses for this Knowledge Base.}>
\SlotEntry <{DependentNetworks} {FSet KBType} {This lists the Knowledge Bases which
rely on the presence of this Knowledge Base to operate.}>
\ClassEntry <{AnyProcess} 21 {Every action which takes place, in LISP, is a \LispFn
(Process) . This corresponds to each function in LISP.}> \CFact SuperClass@AnyCT&U
>
\CFact SubClass@AnyAction AnyEuriskoProcess AnyFunction AnyUnitListProcess>
\SlotsFor {Process}
\SlotEntry <{CVUsedBy} {FSet FunctionType} {Having \Unit (x) \ in \UnitSlot (y:CVUsedBy
) \ means \Unit (x) s cached-value should be updated whenever \Unit (y) s cached-value
changes.}> \SFact Inverse@IUseCVOf>
\SlotEntry <{DefnUsedBy} {FSet FunctionType} {Having \Unit (x) \ in \UnitSlot (y:DefnUsedBy
) \ means \Unit (x) s defn, and maybe its previously stored values, should be updated
whenever \Unit (y) s defn changes}> \SFact Inverse@IUseDefnOf>
\SlotEntry <{WhatToProcess} {FSet UnrestrictedType} {Fill in later.}> \SFact HighLevelDefn@(OneOf TaskList RuleList)>
\SlotEntry <{IUseCVOf} {NotAFormat NotARange} {Having \Unit (y) \ in \UnitSlot (
x:IUseCVOf) \ means if the \Slot (y) \ stored value of some \Unit (z) \ should change,
some \Unit (x) \ value may change as well.}> \SFact Inverse@CVUsedBy>
\SFact HighLevelDefn@(Apply*ingFn GetAllCVs HighLevelDefn)>
\SlotEntry <{IUseDefnOf} {NotAFormat NotARange} {Having \Unit (y) \ in \UnitSlot
(x:IUseDefnOf) \ means \Unit (x) s defn, and maybe its previously stored values,
should be updated whenever \Unit (y) s defn changes}> \SFact Inverse@DefnUsedBy>
\SFact HighLevelDefn@(Apply*ingFn GetAllFNS HighLevelDefn)>
\SlotEntry <{LispFn} {FSingleton FunctionType} {The actual compiled code LISP will
run, to process a process, is stored here.}> \SFact HighLevelDefn@(OneOf LispFnForStoredFn)>
\SlotEntry <{HowToProcess} {FSingleton FunctionType} {This will soon be deleted,
in favor of LispFn.}>
\ClassEntry <{AnyAction} 22 {This includes any activity carried out in the real
world by physical objects.}> \CFact SuperClass@AnyProcess>
\CFact SubClass@AnyActionSequence>
\hmode{\qquad There are currently 12 examples.}\par
\SlotsFor {Action}
\SlotEntry <{SpecAct} {FSet UnitType} {This points to ``refinements'' of this action
-- i.e. activities which are more precisely specified.}> \SFact Inverse@GenlAct>
\SlotEntry <{GenlAct} {FSet UnitType} {This points to actions which are more general
(i.e. at a higher level of abstraction) than the action encoded by this unit. E.g.
\Unit (Locomotions) \EPSILON \UnitSlot (Walking : GenlAct) .}> \SFact Inverse@SpecAct>
\SlotEntry <{SpecAct*} {FSet UnitType} {A list of a unit's SpecAct, THEIR SpecAct,
etc.}> \SFact Inverse@GenlAct*>
\SFact HighLevelDefn@(Starring SpecAct)>
\SlotEntry <{GenlAct*} {FSet UnitType} {A list of a unit's GenlAct, THEIR GenlAct,
etc.}> \SFact Inverse@SpecAct*>
\SFact HighLevelDefn@(Starring GenlAct)>
\ClassEntry <{AnyFunction} 23 {Functions are distinquished from processes in
that the primary purpose of a function is to return a value. Note a process may
be run, in effect, for some side effect. (Yes, this is NOT pure LISP.)}> \CFact SuperClass@
AnyProcess>
\CFact SubClass@AnyFunctional AnyMathFunction AnyPredicate AnyStorableFn AnyUnitListFn
>
\SlotsFor {Function}
\SlotEntry <{SlotsUsedInBuilding} {FSet SlotType} {Lists the slots which this one
contributes to defining.}> \SFact Inverse@AllSBF>
\SlotEntry <{HighLevelDefn} {FSingleton NonNILType} {Here is stored a High Level
Specification of the code to be run. This can be ``parsed'' into a piece of LISP
code, which LISP can execute. Ideally, the information here should be sufficient
to fully specify a function.}>
\SlotEntry <{DataRange} {FSingleton NonNILType} {The value of \UnitSlot (F:DataRange
) \ is used by the range interpreter associated with \Unit (D) , the \Slot (Datatype
) of the function \Unit (S) , to generate a function capable of deciding whether
a value is acceptable or not.}>
\SlotEntry <{Datatype} {FSet (UnitType (*P AnyDatatype))} {\UnitSlot (S:Datatype
) \ points to the list of units in the range of the function, \Unit (F) .}> \SFact Inverse@IsTypeOf>
\SlotEntry <{Format} {FSingleton (UnitType (*P AnyFormat))} {This stores the format
of the result this function is expected to return.}>
\SlotEntry <{DomainType} {FList NonNILType} {This holds a type specification indicating
the domain over which this function is defined.}>
\SlotEntry <{RangeType} {FList NonNILType} {This holds a type specificiation, indicating
the range into which this function will map.}>
\SlotEntry <{FunctionCharacter} {FSet NonNILType} {This holds facts which serve
to describe this function. It is not currently used.}>
\SlotEntry <{Defn} {FSingleton FunctionType} {This function must take in a slot
name \Unit (s) \ and return a function capable of reading/computing \Unit (s) \
in general. Ultimately, \UnitSlot (Defn:Defn) \ should have a self-compiling call
placed in each value it returns.}> \SFact HighLevelDefn@(Apply*ingFn CAR FunctionSpec)>
\SlotEntry <{Definition} {FSingleton NonNILType} {This is not currently used; and
may be meaningless.}>
\SlotEntry <{Domain} {FSet (UnitType (*P AnyClassOfObjects))} {This points to units,
each of which represent a class in the domain of this function.}> \SFact Inverse@DomainOf>
\SlotEntry <{Range} {FSet (UnitType (*P AnyClassOfObjects))} {This points to units,
which each represent a class in the range of this function.}> \SFact Inverse@RangeOf>
\SlotEntry <{IsBuiltFrom} {NotAFormat NotARange} {Appears in unit X, for a type
of slot, and lists the old things out of which X has been defined}> \SFact HighLevelDefn@(Apply*ingFn AllButHead HighLevelDefn)>
\SlotEntry <{UnitsBuiltFrom} {NotAFormat NotARange} {This is going away soon.}> \SFact Inverse@UsedInBuilding>
\SFact HighLevelDefn@(Subsetting IsBuiltFrom Unitp)>
\SlotEntry <{UsingFunctionals} {NotAFormat NotARange} {Appears as a slot in unit
X, and tells how X was defined out of other slots}> \SFact Inverse@CombinerFor>
\SFact HighLevelDefn@(Subsetting UsingFunctions (MemberOf AllIsas AnyFunctional))>
\SlotEntry <{SlotsBuiltFrom} {NotAFormat NotARange} {Fill in later.}> \SFact Inverse@SlotsUsedInBuilding>
\SFact HighLevelDefn@(Subsetting UnitsBuiltFrom (MemberOf AllIsas AnySlot))>
\SlotEntry <{UsingFunctions} {NotAFormat NotARange} {Appears as a slot in unit X,
and tells how X was defined out of other slots}> \SFact HighLevelDefn@(Apply*ingFn OnlyHead HighLevelDefn)>
\SlotEntry <{FunctionSpec} {FSingleton (FunctionType)} {This function takes a slot
name \Unit (S) , returns a list which specifies this function: The first element
is a function capable of reading/computing \Unit (S) , in general, the second,
the range type of this function, and the third, the domain type.}>
\SlotEntry <{PreConditions} {FSet NonNILType} {Fill in later.}>
\ClassEntry <{AnyFunctional} 24 {Each descendant unit represents a function whose
range is a space of functions.}> \CFact SuperClass@AnyFunction>
\CFact SubClass@AnyLogicalOp AnySlotCombiner>
\CFact Direct Examples@ApplyToEach Apply*ingFn ApplyingFn MemberOf>
\SlotsFor {Functional}
\SlotEntry <{GetCVsUsed} {FSingleton FunctionType} {The value of \UnitSlot (SC:GetCVsUsed
) \ is a function which, when applied to a high level defn, HLDefn, returns a list
of storable functions on whose cached values this HLDefn depends. (\Unit (SC) \
is the \LispFn (CAR) \ of that HLDefn.) This computed function can then be stored
on the function \Unit (S) , which will usually be a slot.}>
\SlotEntry <{GetFnsUsed} {FSingleton FunctionType} {The value of \UnitSlot (SC:GetFnsUsed
) \ is a function which, when applied to a high level defn, HLDefn, returns a list
of functions on whose definition this HLDefn depends. This can then be stored on
the function \Unit (S) , which will usually be a slot.}>
\SlotEntry <{CombinerFor} {FSet (UnitType (*P AnyFunction))} {This slot appears
in a unit X for a type of functions, and lists those slots which are defined out
of old ones by using X}> \SFact Inverse@UsingFunctionals>
\SlotEntry <{ToParseParts} {FSingleton FunctionType} {This value is used by each
Slot Combiner to parse its list of arguments.}>
\ClassEntry <{AnyLogicalOp} 25 {Fill in later.}> \CFact SuperClass@AnyFunctional
>
\CFact Direct Examples@L-Optional L-NOT L-OR>
\ClassEntry <{AnySlotCombiner} 26 {An operator which takes some old slots and
defines a new one out of them.}> \CFact SuperClass@AnySlotListFn AnyFunctional>
\hmode{\qquad There are currently 18 examples.}\par
\SlotsFor {SlotCombiner}
\SlotEntry <{FnForInverting} {FSingleton FunctionType} {To find the inverse of a
slot, one can examine the high level definition of that slot, and attempt to invert
that. The \Slot (FnForInverting) \ slot of a slot combiner, \Unit (SC) , is a function
which takes as an argument a high level definition, and returns the high level
definition of a slot which computes the inverse functions from the original slot.
}>
\SlotEntry <{FnForUpdating} {FSingleton FunctionType} {When a new value is placed
in a slot, several other slots in the Knowledge Base must be updated. Such updates
are performed by executing the code stored in the \Slot (KBUpates) \ slot of this
slot. The \Slot (FnForUpdating) \ slot of a slot combiner is used to compute this
\Slot (KBUpdates) . It takes a high level definition as its argument, with this
particular slot combiner as principle slot combiner, and returns, essentially,
the value for the \Slot (KBUpdates) \ slot for this slot (defined by that high level
definition) .}>
\SlotEntry <{FnForCaching} {FSingleton FunctionType} {After the value of a slot
has been computed (using the slot's definition,) RLL then considers storing that
value away. Each slot combiner suggests an appropriate algorithm for deciding whether
to store such values, and where. That procedure is encoded in the \Slot (FnForCaching
) \ slot of the slot combiner. (This function takes a high level definition as an
argument, and returns a function to fill the \Slot (ToCache) \ slot of a slot.)
}>
\ClassEntry <{AnyPredicate} 27 {These functions return a value which is used
as a Boolean -- i.e. they serve to intensionally define a set.}> \CFact SuperClass@
AnyFunction>
\ClassEntry <{AnyStorableFn} 28 {This class contains those functions whose value,
on some input, might be stored, (or cached,) away. Note at least one of the arguments
must be a unit.}> \CFact SuperClass@AnyFunction>
\CFact SubClass@AnyUnitListFn>
\SlotsFor {StorableFn}
\SlotEntry <{ToConfirmValue} {FSingleton FunctionType} {When retrieving a potential
value for some input data, the predicate stored on this function's \Slot (ToConfirmValue
) \ slot is used to see if this value is valid.}>
\SlotEntry <{ToLookUp} {FSingleton FunctionType} {The value of this slot is a function,
which attempts to retrieve a cached value of this function.}>
\SlotEntry <{ToCache} {FSingleton FunctionType} {The function stored here is called
after a value has been calculated. This function then decides whether to store
this value for future use, and if so, where.}>
\SlotEntry <{StoredAList} {FSet (FListN UnrestrictedType UnrestrictedType)} {This
stores some i/o pairs for this function, as an association list.}>
\SlotEntry <{LispFnForStoredFn} {FSingleton FunctionType} {This function, used as
the value for \LispFn (LispFn) , does the following: First try to find the value
by looking it up. If that fails, compute it; and consider caching the results.
Of course, then return the computed (or retrieved) value.}>
\ClassEntry <{AnyUnitListFn} 29 {Here will be any mapping which takes, as an
argument, one or more units}> \CFact SuperClass@AnyStorableFn AnyFunction>
\CFact SubClass@AnySlotGetter AnySlotListFn AnyUnitFunction>
\ClassEntry <{AnySlotGetter} 30 {Examples are the units used to get the list
of slot types which new units, created using some inheritance mechanism, should
have.}> \CFact SuperClass@AnyUnitListFn>
\CFact Direct Examples@PossibleSlotsOfISubClass PossibleSlotsOfITypEx PossibleSlotsOfIExamples
>
\ClassEntry <{AnySlotListFn} 31 {Descendants are functions which takes one or
more slots as arguments.}> \CFact SuperClass@AnyUnitListFn>
\CFact SubClass@AnySlotCombiner>
\ClassEntry <{AnyUnitFunction} 32 {Descendants each represent a mapping which
takes, as an argument, a unit.}> \CFact SuperClass@AnyUnitListFn>
\CFact SubClass@Any$SELF$Slot AnySlot>
\CFact Direct Examples@ThenParts MyKB>
\SlotsFor {UnitFunction}
\SlotEntry <{HandDoneSBF} {FSet SlotType} {This is used to enter the names of slots
(or, in general, functions,) which current slot was built from.}>
\SlotEntry <{UsingSlotCombiners} {NotAFormat NotARange} {Appears as a slot in unit
X, and tells how X was defined out of other slots}> \SFact HighLevelDefn@(Subsetting UsingFunctionals (MemberOf AllIsas AnySlotCombiner))>
\SlotEntry <{ToGetValue} {FSingleton FunctionType} {The function stored on a function's
\Slot (ToGetValue) is invoked when one requests \UnitSlot (x:S) .}>
\SlotEntry <{AllSBF} {FSet SlotType} {This stands for All Slots Built From . It
is used to hold the set of all slots which affect this one -- that is, \UnitSlot
(x:S) \ may have to be invalidated if the \Slot (y) \ slot of some unit is changed,
whenever y \EPSILON \UnitSlot (S:AllSBF) .}> \SFact Inverse@SlotsUsedInBuilding>
\SFact HighLevelDefn@(Unioning SlotsBuiltFrom HandDoneSBF)>
\ClassEntry <{Any$SELF$Slot} 33 {Descendants of this are the oft-spoken syntactic
slots. That is, they each refer to this unit, {\it qua} unit, rather than what
this unit represents. See \Unit (AnyCT&U) \ and \Unit (AnyAT&U) \ to understand
this hackery.}> \CFact SuperClass@AnyUnitFunction>
\hmode{\qquad There are currently 8 examples.}\par
\SlotsFor {$SELF$Slot}
\SlotEntry <{StoredInTypAs} {FSingleton SlotType} {This points to slot which holds
the inheritable value in typical example units.}> \SFact Inverse@StandsForSlot>
\ClassEntry <{AnySlot} 34 {Every function which takes a unit as an argument,
and which MAY BE STORED ON THAT UNIT, is a slot; and descends from \Unit (AnySlot
) .}> \CFact SuperClass@AnyUnitFunction>
\CFact SubClass@AnyField AnySlot-Instances PrimSlot VirtualSlot>
\CFact Direct Examples@Uncle SD Ancestor Child>
\SlotsFor {Slot}
\SlotEntry <{IsEssentialFor} {FSet UnitType} {Some virtual slots must be stored
on a unit for bootstrapping reasons. \UnitSlot (S:IsEssentialFor) \ holds a list
of units which require this \Slot (S) \ slot.}> \SFact Inverse@MyEssentialVirtualSlots>
\SlotEntry <{Inverse} {FSingleton SlotType} {Stating \Unit (S) \ is the \Slot (Inverse
) \ of a \Slot (T) \ means \Unit (x) \EPSILON \UnitSlot (y:S) \ iff \Unit (y) \EPSILON
\UnitSlot (x:T) . The \EPSILON \ relation means \Unit (a) \EQUAL \Unit (b) \ if
\Unit (b) \ is a singleton, otherwise a is in the list, b.}> \SFact Inverse@Inverse>
\SlotEntry <{OrderForToInit} {FSingleton IntegerType} {Each slot will have a value,
stored here, which indicates at what time its ToInitialize function should be invoked
when a new unit is being created. It may use the global variables: uParent, uInheritance,
and uAllInheritantedSlots, to make its decision.}>
\SlotEntry <{SuperSlot} {FSet SlotType} {Stating \Unit (SS) \ is a \Slot (SuperSlot
) \ of \Slot (S) \ means the value of \UnitSlot (x:S) \ will be a subset of the
value of \UnitSlot (x:SS) , for all \Unit (x) \ in their common range.}> \SFact Inverse@SubSlot>
\SlotEntry <{SubSlot} {FSet UnitType} {This is the inverse of \Slot (SuperSlot)
.}> \SFact Inverse@SuperSlot>
\SlotEntry <{MakesSenseFor} {FSet (UnitType (*P AnyArchetype))} {A given slot, \Unit
(S) , may only be defined for certain particular units. \UnitSlot (S:MakesSenseFor
) \ points to a list of typical-example units. This \Slot (S) \ slot makes sense
for each instance of each such unit.}> \SFact Inverse@NewPossibleSlots>
\SlotEntry <{ToPutValue} {FSingleton FunctionType} {The function stored on \UnitSlot
(S:ToPutValue) \ is called whenever putting a new value onto \UnitSlot (U:S) .}>
\SlotEntry <{ToInitialize} {FSingleton FunctionType} {When creating a new unit,
all of the existing inheritance mechanisms first gather a collection of slots, which
are meaningful to this new unit. Each slot, \Unit (S) , is then asked for its \UnitSlot
(S:ToInitialize) \ function, which is then run. It is the responsibility of this
function to actually store an appropriate value on this new unit.}>
\SlotEntry <{SuperSlot*} {FSet SlotType} {A list of a unit's SuperSlot, THEIR SuperSlot,
etc.}> \SFact Inverse@SubSlot*>
\SFact HighLevelDefn@(Starring SuperSlot)>
\SlotEntry <{SubSlot*} {FSet UnitType} {A list of a unit's SubSlot, THEIR SubSlot,
etc.}> \SFact Inverse@SuperSlot*>
\SFact HighLevelDefn@(Starring SubSlot)>
\SlotEntry <{ToAddValue} {FSingleton FunctionType} {Whenever one wishes to add one
a value to the current value of \UnitSlot (U:S) , the function stored on \UnitSlot
(S:ToAddValue) \ is called.}>
\SlotEntry <{ToDeleteValue} {FSingleton FunctionType} {Whenever one wants to delete
a value from the list of values stored on \UnitSlot (U:S) , the function stored
on \UnitSlot (S:ToDeleteValue) \ is called.}>
\SlotEntry <{ToSubstValue} {FSingleton FunctionType} {Whenever one wants to substitute
one value for another, on the list of values stored on \UnitSlot (U:S) , the function
stored on \UnitSlot (S:ToSubstValue) \ is called.}>
\SlotEntry <{KBUpdates} {FSingleton FunctionType} {Whenever a value is stored in
a slot, various changed must be made throughout the Knowledge Bases, for truth
maintanence reasons. A function designed to perform such modifications is stored
in the \Slot (KBUpdates) \ slot of each slot. \UnitSlot (S:KBUpdates) \ is called
whenever the value of \UnitSlot (x:S) \ is changed. \par This \Slot (KBUpdates)
\ is calculated using the \Unit (FnForUpdating) \ slots of the various Slot Combiners
used to define this \Unit (S) \ slot.}>
\SlotEntry <{VerifyAll} {FSingleton FunctionType} {Before accepting a value for
storage on \UnitSlot (U:S) , it is tested for acceptability. This is done by calling
\UnitSlot (S:VerifyAll) \ on this proposed value.}>
\SlotEntry <{VerifyElement} {FSingleton FunctionType} {When adding a new value to
a slot's existing value, or substituting one value for another, it is often costly,
and unnecessary, to check all of the values for acceptability. To verify the validity
of one value, the function stored on \UnitSlot (S:VerifyElement) \ is called on
that proposed new element.}>
\ClassEntry <{AnyField} 35 {Slots on sub-units (that is, units devoted to storing
the value of a slot of a given unit,) are called fields. Those ``slots'' which
appear only in this context are stored under \Unit (AnyField) .}> \CFact SuperClass@
AnySlot>
\CFact Direct Examples@*vaLue* LivesInLocation LivesInSlot LivesInUnit>
\ClassEntry <{AnySlot-Instances} 36 {Aliases used for syntactic slots are stored
under \Unit (AnySlot-Instances) . These are used to hold values which should be
inherited from typical example units; freeing the basic slot to hold the value
pertanent to this particular unit.}> \CFact SuperClass@AnySlot>
\CFact Direct Examples@SlotsNowOrdered-Instances EssentialVirtualSlots-Instances
ToKillMe-Instances ToRenameMe-Instances>
\SlotsFor {Slot-Instances}
\SlotEntry <{StandsForSlot} {FSingleton SlotType} {This points to the name of the
syntactic slot for which this is an alias.}> \SFact Inverse@StoredInTypAs>
\ClassEntry <{PrimSlot} 37 {Primitive slots, which descend from this \Unit (AnyPrimSlot
) , cannot be computed if omitted. (As opposed to virtual slots, which are technically
redundant information, as they can be computed from more basic slots.)}> \CFact SuperClass@
AnySlot>
\CFact SubClass@AnyAccessSlot AnyActionPartOfRule AnyFormatFnSlot CharacterAbility
>
\hmode{\qquad There are currently 105 examples.}\par
\ClassEntry <{AnyAccessSlot} 38 {Descendant of this \Unit (AnyAccessSlot) \ are
slots used to manipulate the units themselves. For efficiency, they all use the
same fast retrieval mechanism to determine their respective values -- \LispFn (
GetAccessFn) .}> \CFact SuperClass@PrimSlot>
\CFact Direct Examples@ToGetValue BeforeGetValue AfterGetValue ToPutValue BeforePutValue
AfterPutValue ToAddValue ToDeleteValue ToSubstValue ToInitialize MyToKillMe ToCacheField
ToCache ToKillValue MyToRenameMe>
\ClassEntry <{AnyFormatFnSlot} 39 {Various bits of information are associated
with each format. When this information is functional, it descends from this \Unit
(AnyFormatFnSlot) .}> \CFact SuperClass@PrimSlot>
\hmode{\qquad There are currently 8 examples.}\par
\ClassEntry <{VirtualSlot} 40 {These slots are redundant, as they could have
been computed from other, more basic slots. (Modulo Garden-Of-Eden conditions. See
\Unit (MyEssentialVirtualSlots) .)}> \CFact SuperClass@AnySlot>
\hmode{\qquad There are currently 115 examples.}\par
\ClassEntry <{AnyUnitListProcess} 41 {These processes take one or more units
(amoung possibly other things) are arguments.}> \CFact SuperClass@AnyProcess>
\CFact SubClass@AnyUnitProcess>
\ClassEntry <{AnyUnitProcess} 42 {These processes take a single unit as its argument.
}> \CFact SuperClass@AnyUnitListProcess>
\CFact Direct Examples@EditUnit>
\ClassEntry <{AnyUnit} 43 {Examples will be things which REPRESENT units... NOTE:
this does NOT include every unit automatically! (In fact, most units represent
some real world object, such as Tree$\#$32, or some conceptual entity, such as Red,
or Function$\#$412.)}> \CFact SuperClass@Anything>
\SlotsFor {Unit}
\SlotEntry <{MyCreatedAs} {FListN (UnitType (*P AnyInheritance)) (FList UnitType
)} {This stores inheritance information about this unit -- indicating, for example,
that it was created as an \Unit (IExamples) \ (read ``Example'') of \Unit (AnySlot
) .}>
\SlotEntry <{MyEssentialVirtualSlots} {FSet SlotType} {These slots are essential
for the Garden of Eden RLL system. Therefore \LispFn (RemoveVirtualSlots) \ is
smart enough to know NOT to remove these slots (i.e. those which \Slot (MyEssentialVirtualSlots
) \ points to) from a unit.}> \SFact Inverse@IsEssentialFor>
\SlotEntry <{MyToRenameMe} {FSingleton FunctionType} {This function is called when
renaming this unit to another name.}>
\SlotEntry <{MyTimeOfCreation} {FSingleton StringType} {This records when this unit
was created.}>
\SlotEntry <{MyCreator} {FSingleton StringType} {This names the user who created
this unit.}>
\SlotEntry <{MyToKillMe} {FSingleton FunctionType} {This function is called when
deleting this unit.}>
\SlotEntry <{MySlotsNowOrdered} {FSet SlotType} {This lists the names of slots which
are currently in the correct order. (For example, \Slot (OrderedPrototypes) \ appears
in some unit's \Slot (MyEssentialVirtualSlots) \ only when the typical example
units stored in \Slot (Prototypes) \ have been arranged in the correct order.)}>
\SlotEntry <{MySensibleSlots} {FSet SlotType} {Only certain slots are defined for
a given unit. This list is stored in that unit's \Slot (MySensibleSlots) .}> \SFact HighLevelDefn@(Composition NewPossibleSlots Prototypes)>
\SlotEntry <{MySlots} {FSet SlotType} {This never cached slot returns the list of
slots belonging to this unit.}> \SFact Inverse@AmUsedIn>
\ClassEntry <{AnyUser} 44 {RLL tries to hold some primitive information about
each user of this system. A unit is devoted to each user, (as well as each recognized
user class) ; and this information is under \Unit (AnyUser) .}> \CFact SuperClass@
AnyCT&U>
\CFact SubClass@AnyHacker>
\CFact Direct Examples@AndyFreeman LarryHines>
\SlotsFor {User}
\SlotEntry <{InformalName} {FSingleton StringType} {This is a name RLL can use to
greet this user.}>
\SlotEntry <{UsualKBs} {FSet KBType} {These are the Knowledge Bases this user usually
wants loaded in.}>
\SlotEntry <{WritingOptions} {FList NonNILType} {When closing a Knowledge Base,
RLL must ask the user several questions. To sidestep this tedious (and often unneccessary
) process, the user can indicate a fixed set of responses to such inquires; which
are stored on this \Slot (WritingOptions) \ slot. When closing the KBs, the user
is now asked a single question -- if he wishes to use these. (Answering No forces
RLL to ask him these questions one by one.) \par The defaulted writing function,
\LispFn (StandardFinishUp) , asks if virtual slots should be removed, if this KB
should be disconnected from the others, and if this KB should be diagnosed; in
that order. Setting \Slot (WritingOptions) \ to (Y N Y) instructs RLL to remove
virtual slots, and diagnose the KB, but not to disconnect it.}>
\SlotEntry <{OpenningOptions} {FList UnrestrictedType} {Like \Slot (WritingOptions
) , this helps the user to avoid a potentially dull task. The value stored here
will be handed to the function called when openning each knowledge base; if the
user indicates he wishes his default setting to be used. \par The only question
\LispFn (StandardStartUp) \ might ask is whethr to reconnect an enterring knowledge
base. Setting the \Slot (OpenningOptions) \ slot to (NIL) means this question will
be asked each time.}>
\SlotEntry <{UserNames} {FSet StringType} {This lists the system names this user
may go by. (Ie values of \LispFn ({ (USERNAME) }) \ which correspond to this person.
)}>
\ClassEntry <{AnyHacker} 45 {This class includes people working on RLL.}> \CFact SuperClass@
AnyUser>
\CFact Direct Examples@DougLenat RussGreiner>
\ClassEntry <{AnyConcreteThing} 46 {Instances refer to tangible objects, (such
as trees,) as opposed to abstract things (such as variables) .}> \CFact SuperClass@
Anything>
\StartIndex
\IS <*vaLue* 6>
\IS <AllExamples 10>
\IS <AllGenls 1>
\IS <AllIsas 1>
\IS <AllSBF 32>
\IS <AllSpecs 1>
\IU <Any$SELF$Slot 33>
\IU <AnyAT&U 2>
\IU <AnyAbstractThing 8>
\IU <AnyAccessSlot 38>
\IU <AnyAction 22>
\IU <AnyActionSequence 13>
\IU <AnyArchetype 4>
\IU <AnyCT&U 9>
\IU <AnyClassOfObjects 10>
\IU <AnyConcreteThing 46>
\IU <AnyDatatype 11>
\IU <AnyDecomposableObject 12>
\IU <AnyDescriptor 5>
\IU <AnyField 35>
\IU <AnyFormat 14>
\IU <AnyFormatFnSlot 39>
\IU <AnyFunction 23>
\IU <AnyFunctional 24>
\IU <AnyHacker 45>
\IU <AnyIndirectPtrFormat 17>
\IU <AnyInheritance 18>
\IU <AnyIntensionalObject 3>
\IU <AnyLogicalOp 25>
\IU <AnyOverhead 19>
\IU <AnyPredicate 27>
\IU <AnyProcess 21>
\IU <AnySlot 34>
\IU <AnySlot-Instances 36>
\IU <AnySlotCombiner 26>
\IU <AnySlotFormat 15>
\IU <AnySlotGetter 30>
\IU <AnySlotListFn 31>
\IU <AnyStatus 20>
\IU <AnyStorableFn 28>
\IU <AnyUnit 43>
\IU <AnyUnitForSlot 6>
\IU <AnyUnitFunction 32>
\IU <AnyUnitListFn 29>
\IU <AnyUnitListProcess 41>
\IU <AnyUnitProcess 42>
\IU <AnyUser 44>
\IU <AnyValueFormat 16>
\IU <AnyVariable 7>
\IU <Anything 1>
\IS <CVUsedBy 21>
\IS <Characteristics 1>
\IS <CombinerFor 24>
\IS <ComposedOf 12>
\IS <DataRange 23>
\IS <Datatype 23>
\IS <Definition 23>
\IS <Defn 23>
\IS <DefnUsedBy 21>
\IS <DependentNetworks 20>
\IS <Descr 1>
\IS <Domain 23>
\IS <DomainOf 10>
\IS <DomainType 23>
\IS <EqualDTSpec 11>
\IS <Examples 10>
\IS <FnForAdding 14>
\IS <FnForCaching 26>
\IS <FnForDeleting 14>
\IS <FnForGetting 14>
\IS <FnForInverting 26>
\IS <FnForKilling 14>
\IS <FnForPutting 14>
\IS <FnForUpdating 26>
\IS <FnForVerifyingAll 14>
\IS <FnForVerifyingElement 14>
\IS <Format 23>
\IS <FormatCharacter 14>
\IS <FunctionCharacter 23>
\IS <FunctionSpec 23>
\IS <GenerateAll 11>
\IS <GenlAct 22>
\IS <GenlAct* 22>
\IS <GenlsModels 10>
\IS <GetCVsUsed 24>
\IS <GetFnsUsed 24>
\IS <GetPossibleSlotsFn 18>
\IS <HandDoneSBF 32>
\IS <HighLevelDefn 23>
\IS <HowToProcess 21>
\IS <IUseCVOf 21>
\IS <IUseDefnOf 21>
\IS <InformalName 44>
\IS <IntensionalExamples 10>
\IS <Inverse 34>
\IS <IsBuiltFrom 23>
\IS <IsEssentialFor 34>
\IS <IsTypeOf 11>
\IS <Isa 1>
\IS <KBUpdates 34>
\IS <KBsConnectedTo 20>
\IS <KBsFNS 20>
\IS <KBsFreeBlockIndex 20>
\IS <KBsUnitIndex 20>
\IS <KBsVARS 20>
\IS <LispFn 21>
\IS <LispFnForStoredFn 28>
\IS <LoadFiles 20>
\IS <MakesSenseFor 34>
\IS <MyCreatedAs 43>
\IS <MyCreator 43>
\IS <MyEssentialVirtualSlots 43>
\IS <MySensibleSlots 43>
\IS <MySlots 43>
\IS <MySlotsNowOrdered 43>
\IS <MyTimeOfCreation 43>
\IS <MyToKillMe 43>
\IS <MyToRenameMe 43>
\IS <NetworkStatus 20>
\IS <Networks 20>
\IS <NewPossibleSlots 4>
\IS <OpenDate 20>
\IS <OpenningOptions 44>
\IS <OrderForToInit 34>
\IS <OrderedPrototypes 1>
\IS <PossibleSlots 4>
\IS <PreConditions 23>
\IU <PrimSlot 37>
\IS <Prototypes 1>
\IS <Range 23>
\IS <RangeInterpreter 11>
\IS <RangeOf 10>
\IS <RangeType 23>
\IS <SlotsBuiltFrom 23>
\IS <SlotsUsedInBuilding 23>
\IS <SpecAct 22>
\IS <SpecAct* 22>
\IS <Specializations 1>
\IS <StandsForSlot 36>
\IS <StdExamples 10>
\IS <StoredAList 28>
\IS <StoredInTypAs 33>
\IS <SubActions 13>
\IS <SubClass 10>
\IS <SubClass* 10>
\IS <SubDT 11>
\IS <SubDT* 11>
\IS <SubSlot 34>
\IS <SubSlot* 34>
\IS <SubTypEx 4>
\IS <SubTypEx* 4>
\IS <SuperClass 10>
\IS <SuperClass* 10>
\IS <SuperDT 11>
\IS <SuperDT* 11>
\IS <SuperSlot 34>
\IS <SuperSlot* 34>
\IS <SuperTypEx 4>
\IS <SuperTypEx* 4>
\IS <ToAddValue 34>
\IS <ToCache 28>
\IS <ToConfirmValue 28>
\IS <ToDeleteValue 34>
\IS <ToGetValue 32>
\IS <ToInitialize 34>
\IS <ToLookUp 28>
\IS <ToParseParts 24>
\IS <ToPutValue 34>
\IS <ToSubstValue 34>
\IS <TotalSoFar 10>
\IS <TypicalExample 10>
\IS <TypicalExampleOf 4>
\IS <UnitsBuiltFrom 23>
\IS <UseToGetSlots 18>
\IS <UserNames 44>
\IS <UsingFunctionals 23>
\IS <UsingFunctions 23>
\IS <UsingSlotCombiners 32>
\IS <UsualKBs 44>
\IS <VerifyAll 34>
\IS <VerifyElement 34>
\IS <VerifyType 11>
\IU <VirtualSlot 40>
\IS <WhatToProcess 21>
\IS <WhenOpeningNetwork 20>
\IS <WhenWritingNetwork 20>
\IS <WritingOptions 44>
\par\vfill\eject\end